//小红的排列构造
import java.util.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int[] ans = new int[a];
        if (a < 3) {
            System.out.print(-1);
            return;
        }
        for (int i = 0; i < a; i++) {
            ans[i] = i + 1;

        }
        //奇数的情况
        if (a % 2 == 1) {
            ans[0] = ans[a - 1];
            ans[a - 1] = 1;
        }
        //偶数的情况
        if (a % 2 == 0) {
            ans[0] = ans[a - 2];
            ans[a - 2] = 1;
        }
        for (int i = 0; i < a; i++) {
            System.out.print(ans[i] + " ");

        }
    }


    //小红的字符生成
    public static void main1(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        StringBuilder str = new StringBuilder();
        char c = 'a';

        while (x != 0) {
            if ((x & 1) == 1) {
                str.append(c);
            }
            //>>=：右移赋值操作符，用于将右移后的结果赋值回原变量。
            //>>不会改变原来的变量
            x >>= 1;
            c++;
        }

        System.out.print(str.toString());
    }


    //游游的字母翻倍
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();//长度
        int k=in.nextInt();//次数
        String s=in.next();//字符串
        for(int i=0;i<k;i++){
            int a=in.nextInt();//左区间
            int b=in.nextInt();//右区间
            StringBuffer arr=new StringBuffer();
            int j=0;
            while(j<n){
                char ch=s.charAt(j);
                arr.append(ch);
                if(j>=a-1&&j<=b-1){
                    arr.append(ch);
                }
                j++;
            }
            s=arr.toString();
            n=s.length();
        }
        System.out.print(s);
    }




    //游游的除2操作
    public static void main4(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读取数组长度
        int n = sc.nextInt();
        int[] arr = new int[n];

        // 读取数组元素
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        // 调用方法计算最少操作次数
        int result = minOperationsToEqualElements(n, arr);
        System.out.println(result);
    }
    public static int minOperationsToEqualElements(int n, int[] arr) {
        Map<Integer, List<Integer>> opsMap = new HashMap<>();

        // 遍历数组中的每个元素
        for (int num : arr) {
            int operations = 0;
            int current = num;

            // 不断将元素除以2，并记录每个中间值和操作次数
            while (current > 0) {
                opsMap.computeIfAbsent(current, k -> new ArrayList<>()).add(operations);
                current /= 2;
                operations++;
            }
        }

        int minOperations = Integer.MAX_VALUE;

        // 遍历所有可能的值，找到最小的操作次数
        for (Map.Entry<Integer, List<Integer>> entry : opsMap.entrySet()) {
            List<Integer> operationsList = entry.getValue();
            if (operationsList.size() == n) {
                int totalOperations = operationsList.stream().mapToInt(Integer::intValue).sum();
                minOperations = Math.min(minOperations, totalOperations);
            }
        }

        return minOperations == Integer.MAX_VALUE ? 0 : minOperations;
    }






        //压缩二维码
        public static void main5(String[] args) {
            Scanner in = new Scanner(System.in);
            int n = in.nextInt(); // 输入一个整数
            n=1<<n;  // 将 n 左移一位，变成 2^n
            StringBuffer s = new StringBuffer();

            // 读取 n 行输入，每行 n 个字符
            for (int i = 0; i < n; i++) {
                String temp = in.next();
                s.append(temp);  // 将每行的字符串追加到 StringBuffer 中
            }

            // 每 4 个字符为一组，计算转换后的十进制数字
            for (int i = 0; i < n * n; i += 4) {
                int num = 0;
                for (int j = 0; j < 4; j++) {
                    if (s.charAt(i + j) == '#') {
                        num += (1 << (4 - j - 1)); // 根据位置更新数值
                    }
                }
                System.out.print(num + " ");  // 输出转换后的数字
            }

    }


    //小欧的数组修改
    public static void main6(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入数组的大小
        int n = scanner.nextInt();
        int[] arr = new int[n];

        // 输入数组元素
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }

        System.out.println(maxFrequencyAfterModification(n, arr));
    }

    public static int maxFrequencyAfterModification(int n, int[] arr) {
        // 使用 HashMap 统计每个元素的出现次数
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        for (int num : arr) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }

        // 找到出现次数最多的元素的频次
        int maxFreq = 0;
        for (int freq : frequencyMap.values()) {
            if (freq > maxFreq) {
                maxFreq = freq;
            }
        }

        // 计算最多的出现次数
        // 如果最大频次等于数组长度，无法通过修改增加频次
        return Math.min(n, maxFreq + 1);
    }






    //小红的好数
        public static void main7(String[] args) {
            Scanner in = new Scanner(System.in);
            int k = in.nextInt();

            int count=0;
            for(int i=98765;i>=0;i--){
                //%d: 表示将一个整数格式化为十进制形式。
                //05:
                //0 表示使用零进行填充。
                //5 表示总共输出至少5个字符的宽度。如果数字的位数不足5位，会用零填充到5位。
                String s=String.format("%05d",i);
                if(isGoodNum(s)){
                    count++;
                    if(count==k){
                        System.out.print(s);
                    }
                }
            }
        }
        //判断是不是好数
        public static boolean isGoodNum(String s){
            //建立一个hashset，Set 的特点是不能包含重复的元素
            Set<Character> set=new HashSet<>();
            //遍历字符串转字符数组的每一个字符
            for(char c:s.toCharArray()){
                //如果set中已经存在了字符c，则返回false
                if(set.contains(c)){
                    return false;
                }
                //没有重复就添加到set里
                set.add(c);
            }
            return true;
        }


        //小红的区间查询
    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int q=in.nextInt();
        int[] arr=new int[n];
        for(int i=0;i<n;i++){
            arr[i]=in.nextInt();
        }
        for(int j=0;j<q;j++){
            int num=in.nextInt();
            int i=in.nextInt();
            int val=in.nextInt();
            if(num==1){
                arr[i-1]=val;
            }else{
                search(arr,i,val);
            }
        }
    }
    public static void search(int[] arr,int i,int val){
        int count=0;
        for(int j=0;j<i;j++){
            if(arr[j]==val){
                count++;
            }
        }
        System.out.println(count);
    }


    //小欧的括号嵌套
    public static void main9(String[] args) {
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        int r=in.nextInt();
        Queue<Character> queue=new LinkedList<>();
        for(int i=0;i<2;i++){
            int x=r;
            while(x!=0){
                if(i==0){
                    queue.offer('(');
                }else{
                    queue.offer(')');
                }
                x--;
            }
        }
        int len=2*n-2*r;
        while(len!=0){
            queue.offer('(');
            queue.offer(')');
            len-=2;
        }
        while(!queue.isEmpty()){
            System.out.print(queue.poll());
        }
    }




    //小欧安排座位
    public static void main10(String[] args) {
        // 读取输入
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        scanner.nextLine();  // 读取换行符
        String s = scanner.nextLine();

        // 初始化答案数组
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            ans[i] = i + 1;  // 将 ans 初始化为 1 到 n 的顺序
        }

        // 存储需要处理的元素（索引 + 1 和位置）
        List<int[]> st = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '1') {
                st.add(new int[]{i + 1, i});  // 存储 (索引+1, 位置)
            }
        }

        if (!st.isEmpty()) {
            // 处理 st 中的数据
            int tmp = st.get(0)[0];
            for (int i = 0; i < st.size() - 1; i++) {
                st.get(i)[0] = st.get(i + 1)[0];
            }
            st.get(st.size() - 1)[0] = tmp;

            // 更新 ans 数组
            for (int[] item : st) {
                ans[item[1]] = item[0];
            }
        }

        // 输出结果
        for (int i = 0; i < n; i++) {
            System.out.print(ans[i] + " ");
        }
        System.out.println();  // 换行
    }



}